/** @preserve
 * jsPDF - PDF Document creation from JavaScript
 * Version ${versionID}
 *                           CommitID ${commitID}
 *
 * Copyright (c) 2010-2014 James Hall <james@parall.ax>, https://github.com/MrRio/jsPDF
 *               2010 Aaron Spike, https://github.com/acspike
 *               2012 Willow Systems Corporation, willow-systems.com
 *               2012 Pablo Hess, https://github.com/pablohess
 *               2012 Florian Jenett, https://github.com/fjenett
 *               2013 Warren Weckesser, https://github.com/warrenweckesser
 *               2013 Youssef Beddad, https://github.com/lifof
 *               2013 Lee Driscoll, https://github.com/lsdriscoll
 *               2013 Stefan Slonevskiy, https://github.com/stefslon
 *               2013 Jeremy Morel, https://github.com/jmorel
 *               2013 Christoph Hartmann, https://github.com/chris-rock
 *               2014 Juan Pablo Gaviria, https://github.com/juanpgaviria
 *               2014 James Makes, https://github.com/dollaruw
 *               2014 Diego Casorran, https://github.com/diegocr
 *               2014 Steven Spungin, https://github.com/Flamenco
 *               2014 Kenneth Glassey, https://github.com/Gavvers
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Contributor(s):
 *    siefkenj, ahwolf, rickygu, Midnith, saintclair, eaparango,
 *    kim3er, mfo, alnorth, Flamenco
 */

/**
 * Creates new jsPDF document object instance.
 *
 * @class
 * @param orientation One of "portrait" or "landscape" (or shortcuts "p" (Default), "l")
 * @param unit        Measurement unit to be used when coordinates are specified.
 *                    One of "pt" (points), "mm" (Default), "cm", "in"
 * @param format      One of 'pageFormats' as shown below, default: a4
 * @returns {jsPDF}
 * @name jsPDF
 */
var jsPDF = (function (global) {
    'use strict';
    var pdfVersion = '1.3',
        pageFormats = { // Size in pt of various paper formats
            'a0': [2383.94, 3370.39], 'a1': [1683.78, 2383.94],
            'a2': [1190.55, 1683.78], 'a3': [841.89, 1190.55],
            'a4': [595.28, 841.89], 'a5': [419.53, 595.28],
            'a6': [297.64, 419.53], 'a7': [209.76, 297.64],
            'a8': [147.40, 209.76], 'a9': [104.88, 147.40],
            'a10': [73.70, 104.88], 'b0': [2834.65, 4008.19],
            'b1': [2004.09, 2834.65], 'b2': [1417.32, 2004.09],
            'b3': [1000.63, 1417.32], 'b4': [708.66, 1000.63],
            'b5': [498.90, 708.66], 'b6': [354.33, 498.90],
            'b7': [249.45, 354.33], 'b8': [175.75, 249.45],
            'b9': [124.72, 175.75], 'b10': [87.87, 124.72],
            'c0': [2599.37, 3676.54], 'c1': [1836.85, 2599.37],
            'c2': [1298.27, 1836.85], 'c3': [918.43, 1298.27],
            'c4': [649.13, 918.43], 'c5': [459.21, 649.13],
            'c6': [323.15, 459.21], 'c7': [229.61, 323.15],
            'c8': [161.57, 229.61], 'c9': [113.39, 161.57],
            'c10': [79.37, 113.39], 'dl': [311.81, 623.62],
            'letter': [612, 792],
            'government-letter': [576, 756],
            'legal': [612, 1008],
            'junior-legal': [576, 360],
            'ledger': [1224, 792],
            'tabloid': [792, 1224],
            'credit-card': [153, 243]
        };

    /**
     * jsPDF's Internal PubSub Implementation.
     * See mrrio.github.io/jsPDF/doc/symbols/PubSub.html
     * Backward compatible rewritten on 2014 by
     * Diego Casorran, https://github.com/diegocr
     *
     * @class
     * @name PubSub
     */
    function PubSub(context) {
        var topics = {};

        this.subscribe = function (topic, callback, once) {
            if (typeof callback !== 'function') {
                return false;
            }

            if (!topics.hasOwnProperty(topic)) {
                topics[topic] = {};
            }

            var id = Math.random().toString(35);
            topics[topic][id] = [callback, !!once];

            return id;
        };

        this.unsubscribe = function (token) {
            for (var topic in topics) {
                if (topics[topic][token]) {
                    delete topics[topic][token];
                    return true;
                }
            }
            return false;
        };

        this.publish = function (topic) {
            if (topics.hasOwnProperty(topic)) {
                var args = Array.prototype.slice.call(arguments, 1), idr = [];

                for (var id in topics[topic]) {
                    var sub = topics[topic][id];
                    try {
                        sub[0].apply(context, args);
                    } catch (ex) {
                        if (global.console) {
                            console.error('jsPDF PubSub Error', ex.message, ex);
                        }
                    }
                    if (sub[1]) idr.push(id);
                }
                if (idr.length) idr.forEach(this.unsubscribe);
            }
        };
    }

    /**
     * @constructor
     * @private
     */
    function jsPDF(orientation, unit, format, compressPdf) {
        var options = {};

        if (typeof orientation === 'object') {
            options = orientation;

            orientation = options.orientation;
            unit = options.unit || unit;
            format = options.format || format;
            compressPdf = options.compress || options.compressPdf || compressPdf;
        }

        // Default options
        unit = unit || 'mm';
        format = format || 'a4';
        orientation = ('' + (orientation || 'P')).toLowerCase();

        var format_as_string = ('' + format).toLowerCase(),
            compress = !!compressPdf && typeof Uint8Array === 'function',
            textColor = options.textColor || '0 g',
            drawColor = options.drawColor || '0 G',
            activeFontSize = options.fontSize || 16,
            lineHeightProportion = options.lineHeight || 1.15,
            lineWidth = options.lineWidth || 0.200025, // 2mm
            objectNumber = 2,  // 'n' Current object number
            outToPages = !1,  // switches where out() prints. outToPages true = push to pages obj. outToPages false = doc builder content
            offsets = [],  // List of offsets. Activated and reset by buildDocument(). Pupulated by various calls buildDocument makes.
            fonts = {},  // collection of font objects, where key is fontKey - a dynamically created label for a given font.
            fontmap = {},  // mapping structure fontName > fontStyle > font key - performance layer. See addFont()
            activeFontKey,      // will be string representing the KEY of the font as combination of fontName + fontStyle

            fontStateStack = [], //

            patterns = {}, // collection of pattern objects
            patternMap = {}, // see fonts

            gStates = {}, // collection of graphic state objects
            gStatesMap = {}, // see fonts
            activeGState = null,

            k,                  // Scale factor
            tmp,
            page = 0,
            currentPage,
            pages = [],
            pagesContext = [], // same index as pages and pagedim
            pagedim = [],
            content = [],
            additionalObjects = [],
            lineCapID = 0,
            lineJoinID = 0,
            content_length = 0,

            renderTargets = {},
            renderTargetMap = {},
            renderTargetStack = [],

            pageX, pageY, pageMatrix, // only used for FormObjects
            pageWidth,
            pageHeight,
            pageMode,
            zoomMode,
            layoutMode,
            documentProperties = {
                'title': '',
                'subject': '',
                'author': '',
                'keywords': '',
                'creator': ''
            },
            API = {},
            events = new PubSub(API),

            /////////////////////
            // Private functions
            /////////////////////
            f2 = function (number) {
                return number.toFixed(2); // Ie, %.2f
            },
            f3 = function (number) {
                return number.toFixed(3); // Ie, %.3f
            },
            padd2 = function (number) {
                return ('0' + parseInt(number)).slice(-2);
            },
            padd2Hex = function (hexString) {
                var s = "00" + hexString;
                return s.substr(s.length - 2);
            },
            out = function (string) {
                if (outToPages) {
                    /* set by beginPage */
                    pages[currentPage].push(string);
                } else {
                    // +1 for '\n' that will be used to join 'content'
                    content_length += string.length + 1;
                    content.push(string);
                }
            },
            newObject = function () {
                // Begin a new object
                objectNumber++;
                offsets[objectNumber] = content_length;
                out(objectNumber + ' 0 obj');
                return objectNumber;
            },
            // Does not output the object until after the pages have been output.
            // Returns an object containing the objectId and content.
            // All pages have been added so the object ID can be estimated to start right after.
            // This does not modify the current objectNumber;  It must be updated after the newObjects are output.
            newAdditionalObject = function () {
                var objId = pages.length * 2 + 1;
                objId += additionalObjects.length;
                var obj = {objId: objId, content: ''};
                additionalObjects.push(obj);
                return obj;
            },
            // Does not output the object.  The caller must call newObjectDeferredBegin(oid) before outputing any data
            newObjectDeferred = function () {
                objectNumber++;
                offsets[objectNumber] = function () {
                    return content_length;
                };
                return objectNumber;
            },
            newObjectDeferredBegin = function (oid) {
                offsets[oid] = content_length;
            },
            putStream = function (str) {
                out('stream');
                out(str);
                out('endstream');
            },
            putPages = function () {
                var n, p, arr, i, deflater, adler32, adler32cs, wPt, hPt;

                adler32cs = global.adler32cs || jsPDF.adler32cs;
                if (compress && typeof adler32cs === 'undefined') {
                    compress = false;
                }

                // outToPages = false as set in endDocument(). out() writes to content.

                for (n = 1; n <= page; n++) {
                    newObject();
                    wPt = (pageWidth = pagedim[n].width) * k;
                    hPt = (pageHeight = pagedim[n].height) * k;
                    out('<</Type /Page');
                    out('/Parent 1 0 R');
                    out('/Resources 2 0 R');
                    out('/MediaBox [0 0 ' + f2(wPt) + ' ' + f2(hPt) + ']');
                    // Added for annotation plugin
                    events.publish('putPage', {pageNumber: n, page: pages[n]});
                    out('/Contents ' + (objectNumber + 1) + ' 0 R');
                    out('>>');
                    out('endobj');

                    // Page content
                    p = pages[n].join('\n');

                    // prepend global change of basis matrix
                    // (Now, instead of converting every coordinate to the pdf coordinate system, we apply a matrix
                    // that does this job for us (however, texts, images and similar objects must be drawn bottom up))
                    p = new Matrix(k, 0, 0, -k, 0, pageHeight).toString() + " cm\n" + p;

                    newObject();
                    if (compress) {
                        arr = [];
                        i = p.length;
                        while (i--) {
                            arr[i] = p.charCodeAt(i);
                        }
                        adler32 = adler32cs.from(p);
                        deflater = new Deflater(6);
                        deflater.append(new Uint8Array(arr));
                        p = deflater.flush();
                        arr = new Uint8Array(p.length + 6);
                        arr.set(new Uint8Array([120, 156]));
                        arr.set(p, 2);
                        arr.set(new Uint8Array([adler32 & 0xFF, (adler32 >> 8) & 0xFF, (adler32 >> 16) & 0xFF, (adler32 >> 24) & 0xFF]), p.length + 2);
                        p = String.fromCharCode.apply(null, arr);
                        out('<</Length ' + p.length + ' /Filter [/FlateDecode]>>');
                    } else {
                        out('<</Length ' + p.length + '>>');
                    }
                    putStream(p);
                    out('endobj');
                }
                offsets[1] = content_length;
                out('1 0 obj');
                out('<</Type /Pages');
                var kids = '/Kids [';
                for (i = 0; i < page; i++) {
                    kids += (3 + 2 * i) + ' 0 R ';
                }
                out(kids + ']');
                out('/Count ' + page);
                out('>>');
                out('endobj');
                events.publish('postPutPages');
            },
            putFont = function (font) {
                font.objectNumber = newObject();
                out('<</BaseFont/' + font.PostScriptName + '/Type/Font');
                if (typeof font.encoding === 'string') {
                    out('/Encoding/' + font.encoding);
                }
                out('/Subtype/Type1>>');
                out('endobj');
            },
            putFonts = function () {
                for (var fontKey in fonts) {
                    if (fonts.hasOwnProperty(fontKey)) {
                        putFont(fonts[fontKey]);
                    }
                }
            },
            putXObject = function (xObject) {
                xObject.objectNumber = newObject();
                out("<<");
                out("/Type /XObject");
                out("/Subtype /Form");
                out("/BBox [" + [
                    f2(xObject.x),
                    f2(xObject.y),
                    f2(xObject.x + xObject.width),
                    f2(xObject.y + xObject.height)
                ].join(" ") + "]");
                out("/Matrix [" + xObject.matrix.toString() + "]");
                // TODO: /Resources

                var p = xObject.pages[1].join("\n");
                out("/Length " + p.length);

                out(">>");
                putStream(p);
                out("endobj");
            },
            putXObjects = function () {
                for (var xObjectKey in renderTargets) {
                    if (renderTargets.hasOwnProperty(xObjectKey)) {
                        putXObject(renderTargets[xObjectKey]);
                    }
                }
            },

            interpolateAndEncodeRGBStream = function (colors, numberSamples) {
                var tValues = [];
                var t;
                var dT = 1.0 / (numberSamples - 1);
                for (t = 0.0; t < 1.0; t += dT) {
                    tValues.push(t);
                }
                tValues.push(1.0);

                // add first and last control point if not present
                if (colors[0].offset != 0.0) {
                    var c0 = {
                        offset: 0.0,
                        color: colors[0].color
                    };
                    colors.unshift(c0)
                }
                if (colors[colors.length - 1].offset != 1.0) {
                    var c1 = {
                        offset: 1.0,
                        color: colors[colors.length - 1].color
                    };
                    colors.push(c1);
                }

                var out = "";
                var index = 0;

                for (var i = 0; i < tValues.length; i++) {
                    t = tValues[i];

                    while (t > colors[index + 1].offset)
                        index++;

                    var a = colors[index].offset;
                    var b = colors[index + 1].offset;
                    var d = (t - a) / (b - a);

                    var aColor = colors[index].color;
                    var bColor = colors[index + 1].color;

                    out += padd2Hex((Math.round((1 - d) * aColor[0] + d * bColor[0])).toString(16))
                        + padd2Hex((Math.round((1 - d) * aColor[1] + d * bColor[1])).toString(16))
                        + padd2Hex((Math.round((1 - d) * aColor[2] + d * bColor[2])).toString(16));
                }
                return out.trim();
            },
            putShadingPattern = function (pattern, numberSamples) {
                /*
       Axial patterns shade between the two points specified in coords, radial patterns between the inner
       and outer circle.

       The user can specify an array (colors) that maps t-Values in [0, 1] to RGB colors. These are now
       interpolated to equidistant samples and written to pdf as a sample (type 0) function.
       */

                // The number of color samples that should be used to describe the shading.
                // The higher, the more accurate the gradient will be.
                numberSamples || (numberSamples = 21);

                var funcObjectNumber = newObject();
                var stream = interpolateAndEncodeRGBStream(pattern.colors, numberSamples);
                out("<< /FunctionType 0");
                out("/Domain [0.0 1.0]");
                out("/Size [" + numberSamples + "]");
                out("/BitsPerSample 8");
                out("/Range [0.0 1.0 0.0 1.0 0.0 1.0]");
                out("/Decode [0.0 1.0 0.0 1.0 0.0 1.0]");
                out("/Length " + stream.length);
                // The stream is Hex encoded
                out("/Filter /ASCIIHexDecode");
                out(">>");
                putStream(stream);
                out("endobj");

                pattern.objectNumber = newObject();
                out("<< /ShadingType " + pattern.type);
                out("/ColorSpace /DeviceRGB");

                var coords = "/Coords ["
                    + f3(parseFloat(pattern.coords[0])) + " "// x1
                    + f3(parseFloat(pattern.coords[1])) + " "; // y1
                if (pattern.type === 2) {
                    // axial
                    coords += f3(parseFloat(pattern.coords[2])) + " " // x2
                        + f3(parseFloat(pattern.coords[3])); // y2
                } else {
                    // radial
                    coords += f3(parseFloat(pattern.coords[2])) + " "// r1
                        + f3(parseFloat(pattern.coords[3])) + " " // x2
                        + f3(parseFloat(pattern.coords[4])) + " " // y2
                        + f3(parseFloat(pattern.coords[5])); // r2
                }
                coords += "]";
                out(coords);

                if (pattern.matrix) {
                    out("/Matrix [" + pattern.matrix.toString() + "]");
                }

                out("/Function " + funcObjectNumber + " 0 R");
                out("/Extend [true true]");
                out(">>");
                out("endobj");
            },
            putTilingPattern = function (pattern) {
                var resourcesObjectNumber = newObject();
                out("<<");
                putResourceDictionary();
                out(">>");
                out("endobj");

                pattern.objectNumber = newObject();
                out("<< /Type /Pattern");
                out("/PatternType 1"); // tiling pattern
                out("/PaintType 1"); // colored tiling pattern
                out("/TilingType 1"); // constant spacing
                out("/BBox [" + pattern.boundingBox.map(f3).join(" ") + "]");
                out("/XStep " + f3(pattern.xStep));
                out("/YStep " + f3(pattern.yStep));
                out("/Length " + pattern.stream.length);
                out("/Resources " + resourcesObjectNumber + " 0 R"); // TODO: resources
                pattern.matrix && out("/Matrix [" + pattern.matrix.toString() + "]");

                out(">>");

                putStream(pattern.stream);

                out("endobj");
            },
            putPatterns = function () {
                var patternKey;
                for (patternKey in patterns) {
                    if (patterns.hasOwnProperty(patternKey)) {
                        if (patterns[patternKey] instanceof API.ShadingPattern) {
                            putShadingPattern(patterns[patternKey]);
                        } else if (patterns[patternKey] instanceof API.TilingPattern) {
                            putTilingPattern(patterns[patternKey]);
                        }
                    }
                }
            },

            putGState = function (gState) {
                gState.objectNumber = newObject();
                out("<<");
                for (var p in gState) {
                    switch (p) {
                        case "opacity":
                            out("/ca " + f2(gState[p]));
                            break;
                    }
                }
                out(">>");
                out("endobj");
            },
            putGStates = function () {
                var gStateKey;
                for (gStateKey in gStates) {
                    if (gStates.hasOwnProperty(gStateKey)) {
                        putGState(gStates[gStateKey]);
                    }
                }
            },

            putXobjectDict = function () {
                for (var xObjectKey in renderTargets) {
                    if (renderTargets.hasOwnProperty(xObjectKey) && renderTargets[xObjectKey].objectNumber >= 0) {
                        out("/" + xObjectKey + " " + renderTargets[xObjectKey].objectNumber + " 0 R");
                    }
                }

                events.publish('putXobjectDict');
            },

            putShadingPatternDict = function () {
                for (var patternKey in patterns) {
                    if (patterns.hasOwnProperty(patternKey) && patterns[patternKey] instanceof API.ShadingPattern && patterns[patternKey].objectNumber >= 0) {
                        out("/" + patternKey + " " + patterns[patternKey].objectNumber + " 0 R");
                    }
                }

                events.publish("putShadingPatternDict");
            },

            putTilingPatternDict = function () {
                for (var patternKey in patterns) {
                    if (patterns.hasOwnProperty(patternKey) && patterns[patternKey] instanceof API.TilingPattern && patterns[patternKey].objectNumber >= 0) {
                        out("/" + patternKey + " " + patterns[patternKey].objectNumber + " 0 R");
                    }
                }

                events.publish("putTilingPatternDict");
            },

            putGStatesDict = function () {
                var gStateKey;
                for (gStateKey in gStates) {
                    if (gStates.hasOwnProperty(gStateKey) && gStates[gStateKey].objectNumber >= 0) {
                        out("/" + gStateKey + " " + gStates[gStateKey].objectNumber + " 0 R");
                    }
                }

                events.publish("putGStateDict");
            },
            putResourceDictionary = function () {
                out('/ProcSet [/PDF /Text /ImageB /ImageC /ImageI]');
                out('/Font <<');
                // Do this for each font, the '1' bit is the index of the font
                for (var fontKey in fonts) {
                    if (fonts.hasOwnProperty(fontKey)) {
                        out('/' + fontKey + ' ' + fonts[fontKey].objectNumber + ' 0 R');
                    }
                }
                out('>>');

                out("/Shading <<");
                putShadingPatternDict();
                out(">>");

                out("/Pattern <<");
                putTilingPatternDict();
                out(">>");

                out("/ExtGState <<");
                putGStatesDict();
                out('>>');

                out('/XObject <<');
                putXobjectDict();
                out('>>');
            },
            putResources = function () {
                putFonts();
                putGStates();
                putXObjects();
                putPatterns();
                events.publish('putResources');
                // Resource dictionary
                offsets[2] = content_length;
                out('2 0 obj');
                out('<<');
                putResourceDictionary();
                out('>>');
                out('endobj');
                events.publish('postPutResources');
            },
            putAdditionalObjects = function () {
                events.publish('putAdditionalObjects');
                for (var i = 0; i < additionalObjects.length; i++) {
                    var obj = additionalObjects[i];
                    offsets[obj.objId] = content_length;
                    out(obj.objId + ' 0 obj');
                    out(obj.content);
                    out('endobj');
                }
                objectNumber += additionalObjects.length;
                events.publish('postPutAdditionalObjects');
            },
            addToFontDictionary = function (fontKey, fontName, fontStyle) {
                // this is mapping structure for quick font key lookup.
                // returns the KEY of the font (ex: "F1") for a given
                // pair of font name and type (ex: "Arial". "Italic")
                if (!fontmap.hasOwnProperty(fontName)) {
                    fontmap[fontName] = {};
                }
                fontmap[fontName][fontStyle] = fontKey;
            },
            /**
             * FontObject describes a particular font as member of an instnace of jsPDF
             *
             * It's a collection of properties like 'id' (to be used in PDF stream),
             * 'fontName' (font's family name), 'fontStyle' (font's style variant label)
             *
             * @public
             * @property id {String} PDF-document-instance-specific label assinged to the font.
             * @property PostScriptName {String} PDF specification full name for the font
             * @property encoding {Object} Encoding_name-to-Font_metrics_object mapping.
             * @name FontObject
             */
            addFont = function (PostScriptName, fontName, fontStyle, encoding) {
                var fontKey = 'F' + (Object.keys(fonts).length + 1).toString(10),
                    // This is FontObject
                    font = fonts[fontKey] = {
                        'id': fontKey,
                        'PostScriptName': PostScriptName,
                        'fontName': fontName,
                        'fontStyle': fontStyle,
                        'encoding': encoding,
                        'metadata': {}
                    };
                addToFontDictionary(fontKey, fontName, fontStyle);
                events.publish('addFont', font);

                return fontKey;
            },
            addFonts = function () {

                var HELVETICA = "helvetica",
                    TIMES = "times",
                    COURIER = "courier",
                    NORMAL = "normal",
                    BOLD = "bold",
                    ITALIC = "italic",
                    BOLD_ITALIC = "bolditalic",
                    encoding = 'StandardEncoding',
                    ZAPF = "zapfdingbats",
                    standardFonts = [
                        ['Helvetica', HELVETICA, NORMAL],
                        ['Helvetica-Bold', HELVETICA, BOLD],
                        ['Helvetica-Oblique', HELVETICA, ITALIC],
                        ['Helvetica-BoldOblique', HELVETICA, BOLD_ITALIC],
                        ['Courier', COURIER, NORMAL],
                        ['Courier-Bold', COURIER, BOLD],
                        ['Courier-Oblique', COURIER, ITALIC],
                        ['Courier-BoldOblique', COURIER, BOLD_ITALIC],
                        ['Times-Roman', TIMES, NORMAL],
                        ['Times-Bold', TIMES, BOLD],
                        ['Times-Italic', TIMES, ITALIC],
                        ['Times-BoldItalic', TIMES, BOLD_ITALIC],
                        ['ZapfDingbats', ZAPF]
                    ];

                for (var i = 0, l = standardFonts.length; i < l; i++) {
                    var fontKey = addFont(
                        standardFonts[i][0],
                        standardFonts[i][1],
                        standardFonts[i][2],
                        encoding);

                    // adding aliases for standard fonts, this time matching the capitalization
                    var parts = standardFonts[i][0].split('-');
                    addToFontDictionary(fontKey, parts[0], parts[1] || '');
                }
                events.publish('addFonts', {fonts: fonts, dictionary: fontmap});
            },
            matrixMult = function (m1, m2) {
                return new Matrix(
                    m1.a * m2.a + m1.b * m2.c,
                    m1.a * m2.b + m1.b * m2.d,
                    m1.c * m2.a + m1.d * m2.c,
                    m1.c * m2.b + m1.d * m2.d,
                    m1.e * m2.a + m1.f * m2.c + m2.e,
                    m1.e * m2.b + m1.f * m2.d + m2.f
                );
            },
            Matrix = function (a, b, c, d, e, f) {
                this.a = a;
                this.b = b;
                this.c = c;
                this.d = d;
                this.e = e;
                this.f = f;
            };

        Matrix.prototype = {
            toString: function () {
                return [
                    f3(this.a),
                    f3(this.b),
                    f3(this.c),
                    f3(this.d),
                    f3(this.e),
                    f3(this.f)
                ].join(" ");
            }
        };

        var unitMatrix = new Matrix(1, 0, 0, 1, 0, 0),

            // Used (1) to save the current stream state to the XObjects stack and (2) to save completed form
            // objects in the xObjects map.
            RenderTarget = function () {
                this.page = page;
                this.currentPage = currentPage;
                this.pages = pages.slice(0);
                this.pagedim = pagedim.slice(0);
                this.pagesContext = pagesContext.slice(0);
                this.x = pageX;
                this.y = pageY;
                this.matrix = pageMatrix;
                this.width = pageWidth;
                this.height = pageHeight;

                this.id = ""; // set by endFormObject()
                this.objectNumber = -1; // will be set by putXObject()
            };

        RenderTarget.prototype = {
            restore: function () {
                page = this.page;
                currentPage = this.currentPage;
                pagesContext = this.pagesContext;
                pagedim = this.pagedim;
                pages = this.pages;
                pageX = this.x;
                pageY = this.y;
                pageMatrix = this.matrix;
                pageWidth = this.width;
                pageHeight = this.height;
            }
        };

        var beginNewRenderTarget = function (x, y, width, height, matrix) {
                // save current state
                renderTargetStack.push(new RenderTarget());

                // clear pages
                page = currentPage = 0;
                pages = [];
                pageX = x;
                pageY = y;

                pageMatrix = matrix;

                beginPage(width, height);
            },

            endFormObject = function (key) {
                // only add it if it is not already present (the keys provided by the user must be unique!)
                if (renderTargetMap[key])
                    return;

                // save the created xObject
                var newXObject = new RenderTarget();

                var xObjectId = 'Xo' + (Object.keys(renderTargets).length + 1).toString(10);
                newXObject.id = xObjectId;

                renderTargetMap[key] = xObjectId;
                renderTargets[xObjectId] = newXObject;

                events.publish('addFormObject', newXObject);

                // restore state from stack
                renderTargetStack.pop().restore();
            },

            /**
             * Adds a new pattern for later use.
             * @param {String} key The key by it can be referenced later. The keys must be unique!
             * @param {API.Pattern} pattern The pattern
             */
            addPattern = function (key, pattern) {
                // only add it if it is not already present (the keys provided by the user must be unique!)
                if (patternMap[key])
                    return;

                var prefix = pattern instanceof API.ShadingPattern ? "Sh" : "P";
                var patternKey = prefix + (Object.keys(patterns).length + 1).toString(10);
                pattern.id = patternKey;

                patternMap[key] = patternKey;
                patterns[patternKey] = pattern;

                events.publish('addPattern', pattern);
            },

            /**
             * Adds a new Graphics State. Duplicates are automatically eliminated.
             * @param {String} key Might also be null, if no later reference to this gState is needed
             * @param {Object} gState The gState object
             */
            addGState = function (key, gState) {
                // only add it if it is not already present (the keys provided by the user must be unique!)
                if (key && gStatesMap[key])
                    return;

                var duplicate = false;
                for (var s in gStates) {
                    if (gStates.hasOwnProperty(s)) {
                        if (gStates[s].equals(gState)) {
                            duplicate = true;
                            break;
                        }
                    }
                }

                if (duplicate) {
                    gState = gStates[s];
                } else {
                    var gStateKey = 'GS' + (Object.keys(gStates).length + 1).toString(10);
                    gStates[gStateKey] = gState;
                    gState.id = gStateKey;
                }

                // several user keys may point to the same GState object
                key && (gStatesMap[key] = gState.id);

                events.publish('addGState', gState);

                return gState;
            },
            SAFE = function __safeCall(fn) {
                fn.foo = function __safeCallWrapper() {
                    try {
                        return fn.apply(this, arguments);
                    } catch (e) {
                        var stack = e.stack || '';
                        if (~stack.indexOf(' at ')) stack = stack.split(" at ")[1];
                        var m = "Error in function " + stack.split("\n")[0].split('<')[0] + ": " + e.message;
                        if (global.console) {
                            global.console.error(m, e);
                            if (global.alert) alert(m);
                        } else {
                            throw new Error(m);
                        }
                    }
                };
                fn.foo.bar = fn;
                return fn.foo;
            },
            to8bitStream = function (text, flags) {
                /**
                 * PDF 1.3 spec:
                 * "For text strings encoded in Unicode, the first two bytes must be 254 followed by
                 * 255, representing the Unicode byte order marker, U+FEFF. (This sequence conflicts
                 * with the PDFDocEncoding character sequence thorn ydieresis, which is unlikely
                 * to be a meaningful beginning of a word or phrase.) The remainder of the
                 * string consists of Unicode character codes, according to the UTF-16 encoding
                 * specified in the Unicode standard, version 2.0. Commonly used Unicode values
                 * are represented as 2 bytes per character, with the high-order byte appearing first
                 * in the string."
                 *
                 * In other words, if there are chars in a string with char code above 255, we
                 * recode the string to UCS2 BE - string doubles in length and BOM is prepended.
                 *
                 * HOWEVER!
                 * Actual *content* (body) text (as opposed to strings used in document properties etc)
                 * does NOT expect BOM. There, it is treated as a literal GID (Glyph ID)
                 *
                 * Because of Adobe's focus on "you subset your fonts!" you are not supposed to have
                 * a font that maps directly Unicode (UCS2 / UTF16BE) code to font GID, but you could
                 * fudge it with "Identity-H" encoding and custom CIDtoGID map that mimics Unicode
                 * code page. There, however, all characters in the stream are treated as GIDs,
                 * including BOM, which is the reason we need to skip BOM in content text (i.e. that
                 * that is tied to a font).
                 *
                 * To signal this "special" PDFEscape / to8bitStream handling mode,
                 * API.text() function sets (unless you overwrite it with manual values
                 * given to API.text(.., flags) )
                 * flags.autoencode = true
                 * flags.noBOM = true
                 *
                 * ===================================================================================
                 * `flags` properties relied upon:
                 *   .sourceEncoding = string with encoding label.
                 *                     "Unicode" by default. = encoding of the incoming text.
                 *                     pass some non-existing encoding name
                 *                     (ex: 'Do not touch my strings! I know what I am doing.')
                 *                     to make encoding code skip the encoding step.
                 *   .outputEncoding = Either valid PDF encoding name
                 *                     (must be supported by jsPDF font metrics, otherwise no encoding)
                 *                     or a JS object, where key = sourceCharCode, value = outputCharCode
                 *                     missing keys will be treated as: sourceCharCode === outputCharCode
                 *   .noBOM
                 *       See comment higher above for explanation for why this is important
                 *   .autoencode
                 *       See comment higher above for explanation for why this is important
                 */

                var i, l, sourceEncoding, encodingBlock, outputEncoding, newtext, isUnicode, ch, bch;

                flags = flags || {};
                sourceEncoding = flags.sourceEncoding || 'Unicode';
                outputEncoding = flags.outputEncoding;

                // This 'encoding' section relies on font metrics format
                // attached to font objects by, among others,
                // "Willow Systems' standard_font_metrics plugin"
                // see jspdf.plugin.standard_font_metrics.js for format
                // of the font.metadata.encoding Object.
                // It should be something like
                //   .encoding = {'codePages':['WinANSI....'], 'WinANSI...':{code:code, ...}}
                //   .widths = {0:width, code:width, ..., 'fof':divisor}
                //   .kerning = {code:{previous_char_code:shift, ..., 'fof':-divisor},...}
                if ((flags.autoencode || outputEncoding) &&
                    fonts[activeFontKey].metadata &&
                    fonts[activeFontKey].metadata[sourceEncoding] &&
                    fonts[activeFontKey].metadata[sourceEncoding].encoding) {
                    encodingBlock = fonts[activeFontKey].metadata[sourceEncoding].encoding;

                    // each font has default encoding. Some have it clearly defined.
                    if (!outputEncoding && fonts[activeFontKey].encoding) {
                        outputEncoding = fonts[activeFontKey].encoding;
                    }

                    // Hmmm, the above did not work? Let's try again, in different place.
                    if (!outputEncoding && encodingBlock.codePages) {
                        outputEncoding = encodingBlock.codePages[0]; // let's say, first one is the default
                    }

                    if (typeof outputEncoding === 'string') {
                        outputEncoding = encodingBlock[outputEncoding];
                    }
                    // we want output encoding to be a JS Object, where
                    // key = sourceEncoding's character code and
                    // value = outputEncoding's character code.
                    if (outputEncoding) {
                        isUnicode = false;
                        newtext = [];
                        for (i = 0, l = text.length; i < l; i++) {
                            ch = outputEncoding[text.charCodeAt(i)];
                            if (ch) {
                                newtext.push(
                                    String.fromCharCode(ch));
                            } else {
                                newtext.push(
                                    text[i]);
                            }

                            // since we are looping over chars anyway, might as well
                            // check for residual unicodeness
                            if (newtext[i].charCodeAt(0) >> 8) {
                                /* more than 255 */
                                isUnicode = true;
                            }
                        }
                        text = newtext.join('');
                    }
                }

                i = text.length;
                // isUnicode may be set to false above. Hence the triple-equal to undefined
                while (isUnicode === undefined && i !== 0) {
                    if (text.charCodeAt(i - 1) >> 8) {
                        /* more than 255 */
                        isUnicode = true;
                    }
                    i--;
                }
                if (!isUnicode) {
                    return text;
                }

                newtext = flags.noBOM ? [] : [254, 255];
                for (i = 0, l = text.length; i < l; i++) {
                    ch = text.charCodeAt(i);
                    bch = ch >> 8; // divide by 256
                    if (bch >> 8) {
                        /* something left after dividing by 256 second time */
                        throw new Error("Character at position " + i + " of string '"
                            + text + "' exceeds 16bits. Cannot be encoded into UCS-2 BE");
                    }
                    newtext.push(bch);
                    newtext.push(ch - (bch << 8));
                }
                return String.fromCharCode.apply(undefined, newtext);
            },
            pdfEscape = function (text, flags) {
                /**
                 * Replace '/', '(', and ')' with pdf-safe versions
                 *
                 * Doing to8bitStream does NOT make this PDF display unicode text. For that
                 * we also need to reference a unicode font and embed it - royal pain in the rear.
                 *
                 * There is still a benefit to to8bitStream - PDF simply cannot handle 16bit chars,
                 * which JavaScript Strings are happy to provide. So, while we still cannot display
                 * 2-byte characters property, at least CONDITIONALLY converting (entire string containing)
                 * 16bit chars to (USC-2-BE) 2-bytes per char + BOM streams we ensure that entire PDF
                 * is still parseable.
                 * This will allow immediate support for unicode in document properties strings.
                 */
                return to8bitStream(text, flags).replace(/\\/g, '\\\\').replace(/\(/g, '\\(').replace(/\)/g, '\\)');
            },
            putInfo = function () {
                out('/Producer (jsPDF ' + jsPDF.version + ')');
                for (var key in documentProperties) {
                    if (documentProperties.hasOwnProperty(key) && documentProperties[key]) {
                        out('/' + key.substr(0, 1).toUpperCase() + key.substr(1)
                            + ' (' + pdfEscape(documentProperties[key]) + ')');
                    }
                }
                var created = new Date(),
                    tzoffset = created.getTimezoneOffset(),
                    tzsign = tzoffset < 0 ? '+' : '-',
                    tzhour = Math.floor(Math.abs(tzoffset / 60)),
                    tzmin = Math.abs(tzoffset % 60),
                    tzstr = [tzsign, padd2(tzhour), "'", padd2(tzmin), "'"].join('');
                out(['/CreationDate (D:',
                    created.getFullYear(),
                    padd2(created.getMonth() + 1),
                    padd2(created.getDate()),
                    padd2(created.getHours()),
                    padd2(created.getMinutes()),
                    padd2(created.getSeconds()), tzstr, ')'].join(''));
            },
            putCatalog = function () {
                out('/Type /Catalog');
                out('/Pages 1 0 R');
                // PDF13ref Section 7.2.1
                if (!zoomMode) zoomMode = 'fullwidth';
                switch (zoomMode) {
                    case 'fullwidth'  :
                        out('/OpenAction [3 0 R /FitH null]');
                        break;
                    case 'fullheight' :
                        out('/OpenAction [3 0 R /FitV null]');
                        break;
                    case 'fullpage'   :
                        out('/OpenAction [3 0 R /Fit]');
                        break;
                    case 'original'   :
                        out('/OpenAction [3 0 R /XYZ null null 1]');
                        break;
                    default:
                        var pcn = '' + zoomMode;
                        if (pcn.substr(pcn.length - 1) === '%')
                            zoomMode = parseInt(zoomMode) / 100;
                        if (typeof zoomMode === 'number') {
                            out('/OpenAction [3 0 R /XYZ null null ' + f2(zoomMode) + ']');
                        }
                }
                if (!layoutMode) layoutMode = 'continuous';
                switch (layoutMode) {
                    case 'continuous' :
                        out('/PageLayout /OneColumn');
                        break;
                    case 'single'     :
                        out('/PageLayout /SinglePage');
                        break;
                    case 'two':
                    case 'twoleft'    :
                        out('/PageLayout /TwoColumnLeft');
                        break;
                    case 'tworight'   :
                        out('/PageLayout /TwoColumnRight');
                        break;
                }
                if (pageMode) {
                    /**
                     * A name object specifying how the document should be displayed when opened:
                     * UseNone      : Neither document outline nor thumbnail images visible -- DEFAULT
                     * UseOutlines  : Document outline visible
                     * UseThumbs    : Thumbnail images visible
                     * FullScreen   : Full-screen mode, with no menu bar, window controls, or any other window visible
                     */
                    out('/PageMode /' + pageMode);
                }
                events.publish('putCatalog');
            },
            putTrailer = function () {
                out('/Size ' + (objectNumber + 1));
                out('/Root ' + objectNumber + ' 0 R');
                out('/Info ' + (objectNumber - 1) + ' 0 R');
            },
            beginPage = function (width, height) {
                // Dimensions are stored as user units and converted to points on output
                var orientation = typeof height === 'string' && height.toLowerCase();
                if (typeof width === 'string') {
                    var format = width.toLowerCase();
                    if (pageFormats.hasOwnProperty(format)) {
                        width = pageFormats[format][0] / k;
                        height = pageFormats[format][1] / k;
                    }
                }
                if (Array.isArray(width)) {
                    height = width[1];
                    width = width[0];
                }
                //if (orientation) {
                //	switch(orientation.substr(0,1)) {
                //		case 'l': if (height > width ) orientation = 's'; break;
                //		case 'p': if (width > height ) orientation = 's'; break;
                //	}
                // TODO: What is the reason for this (for me it only seems to raise bugs)?
                //	if (orientation === 's') { tmp = width; width = height; height = tmp; }
                //}
                outToPages = true;
                pages[++page] = [];
                pagedim[page] = {
                    width: Number(width) || pageWidth,
                    height: Number(height) || pageHeight
                };
                pagesContext[page] = {};
                _setPage(page);
            },
            _addPage = function () {
                beginPage.apply(this, arguments);
                // Set line width
                out(f2(lineWidth) + ' w');
                // Set draw color
                out(drawColor);
                // resurrecting non-default line caps, joins
                if (lineCapID !== 0) {
                    out(lineCapID + ' J');
                }
                if (lineJoinID !== 0) {
                    out(lineJoinID + ' j');
                }
                events.publish('addPage', {pageNumber: page});
            },
            _deletePage = function (n) {
                if (n > 0 && n <= page) {
                    pages.splice(n, 1);
                    pagedim.splice(n, 1);
                    page--;
                    if (currentPage > page) {
                        currentPage = page;
                    }
                    this.setPage(currentPage);
                }
            },
            _setPage = function (n) {
                if (n > 0 && n <= page) {
                    currentPage = n;
                    pageWidth = pagedim[n].width;
                    pageHeight = pagedim[n].height;
                }
            },
            /**
             * Returns a document-specific font key - a label assigned to a
             * font name + font type combination at the time the font was added
             * to the font inventory.
             *
             * Font key is used as label for the desired font for a block of text
             * to be added to the PDF document stream.
             * @private
             * @function
             * @param {String} fontName can be undefined on "falthy" to indicate "use current"
             * @param {String} fontStyle can be undefined on "falthy" to indicate "use current"
             * @returns {String} Font key.
             */
            getFont = function (fontName, fontStyle) {
                var key;

                fontName = fontName !== undefined ? fontName : fonts[activeFontKey].fontName;
                fontStyle = fontStyle !== undefined ? fontStyle : fonts[activeFontKey].fontStyle;

                if (fontName !== undefined) {
                    fontName = fontName.toLowerCase();
                }
                switch (fontName) {
                    case 'sans-serif':
                    case 'verdana':
                    case 'arial':
                    case 'helvetica':
                        fontName = 'helvetica';
                        break;
                    case 'fixed':
                    case 'monospace':
                    case 'terminal':
                    case 'courier':
                        fontName = 'courier';
                        break;
                    case 'serif':
                    case 'cursive':
                    case 'fantasy':
                    default:
                        fontName = 'times';
                        break;
                }

                try {
                    // get a string like 'F3' - the KEY corresponding tot he font + type combination.
                    key = fontmap[fontName][fontStyle];
                } catch (e) {
                }

                if (!key) {
                    //throw new Error("Unable to look up font label for font '" + fontName + "', '"
                    //+ fontStyle + "'. Refer to getFontList() for available fonts.");
                    key = fontmap['times'][fontStyle];
                    if (key == null) {
                        key = fontmap['times']['normal'];
                    }
                }
                return key;
            },
            buildDocument = function () {

                outToPages = false; // switches out() to content
                objectNumber = 2;
                content = [];
                offsets = [];
                additionalObjects = [];

                // putHeader()
                out('%PDF-' + pdfVersion);

                putPages();

                // Must happen after putPages
                // Modifies current object Id
                putAdditionalObjects();

                putResources();

                // Info
                newObject();
                out('<<');
                putInfo();
                out('>>');
                out('endobj');

                // Catalog
                newObject();
                out('<<');
                putCatalog();
                out('>>');
                out('endobj');

                // Cross-ref
                var o = content_length, i, p = "0000000000";
                out('xref');
                out('0 ' + (objectNumber + 1));
                out(p + ' 65535 f ');
                for (i = 1; i <= objectNumber; i++) {
                    var offset = offsets[i];
                    if (typeof offset === 'function') {
                        out((p + offsets[i]()).slice(-10) + ' 00000 n ');
                    } else {
                        out((p + offsets[i]).slice(-10) + ' 00000 n ');
                    }
                }
                // Trailer
                out('trailer');
                out('<<');
                putTrailer();
                out('>>');
                out('startxref');
                out(o);
                out('%%EOF');

                outToPages = true;

                return content.join('\n');
            },

            getStyle = function (style) {
                // see path-painting operators in PDF spec
                var op = 'n'; // none
                if (style === "D") {
                    op = 'S'; // stroke
                } else if (style === 'F') {
                    op = 'f'; // fill
                } else if (style === 'FD' || style === 'DF') {
                    op = 'B'; // both
                } else if (style === 'f' || style === 'f*' || style === 'B' || style === 'B*') {
                    /*
				Allow direct use of these PDF path-painting operators:
				- f	fill using nonzero winding number rule
				- f*	fill using even-odd rule
				- B	fill then stroke with fill using non-zero winding number rule
				- B*	fill then stroke with fill using even-odd rule
				*/
                    op = style;
                }
                return op;
            },
            // puts the style for the previously drawn path. If a patternKey is provided, the pattern is used to fill
            // the path. Use patternMatrix to transform the pattern to rhe right location.
            putStyle = function (style, patternKey, patternData) {
                style = getStyle(style);

                // stroking / filling / both the path
                if (!patternKey) {
                    out(style);
                    return;
                }

                patternData || (patternData = unitMatrix);

                var patternId = patternMap[patternKey];
                var pattern = patterns[patternId];

                if (pattern instanceof API.ShadingPattern) {
                    out("q");
                    out("W " + style);

                    if (pattern.gState) {
                        API.setGState(pattern.gState);
                    }

                    out(patternData.toString() + " cm");
                    out("/" + patternId + " sh");
                    out("Q");
                } else if (pattern instanceof API.TilingPattern) {
                    // pdf draws patterns starting at the bottom left corner and they are not affected by the global transformation,
                    // so we must flip them
                    var matrix = new Matrix(1, 0, 0, -1, 0, pageHeight);

                    if (patternData.matrix) {
                        matrix = matrixMult(patternData.matrix || unitMatrix, matrix);

                        // we cannot apply a matrix to the pattern on use so we must abuse the pattern matrix and create new instances
                        // for each use
                        patternId = pattern.createClone(patternKey, patternData.boundingBox, patternData.xStep, patternData.yStep, matrix).id;
                    }

                    out("q");
                    out("/Pattern cs");
                    out("/" + patternId + " scn");

                    if (pattern.gState) {
                        API.setGState(pattern.gState);
                    }

                    out(style);
                    out("Q");
                }
            },

            getArrayBuffer = function () {
                var data = buildDocument(), len = data.length,
                    ab = new ArrayBuffer(len), u8 = new Uint8Array(ab);

                while (len--) u8[len] = data.charCodeAt(len);
                return ab;
            },
            getBlob = function () {
                return new Blob([getArrayBuffer()], {type: "application/pdf"});
            },
            /**
             * Generates the PDF document.
             *
             * If `type` argument is undefined, output is raw body of resulting PDF returned as a string.
             *
             * @param {String} type A string identifying one of the possible output types.
             * @param {Object} options An object providing some additional signalling to PDF generator.
             * @function
             * @returns {jsPDF}
             * @methodOf jsPDF#
             * @name output
             */
            output = SAFE(function (type, options) {
                var datauri = ('' + type).substr(0, 6) === 'dataur'
                    ? 'data:application/pdf;base64,' + btoa(buildDocument()) : 0;

                switch (type) {
                    case undefined:
                        return buildDocument();
                    case 'save':
                        if (navigator.getUserMedia) {
                            if (global.URL === undefined
                                || global.URL.createObjectURL === undefined) {
                                return API.output('dataurlnewwindow');
                            }
                        }
                        saveAs(getBlob(), options);
                        if (typeof saveAs.unload === 'function') {
                            if (global.setTimeout) {
                                setTimeout(saveAs.unload, 911);
                            }
                        }
                        break;
                    case 'arraybuffer':
                        return getArrayBuffer();
                    case 'blob':
                        return getBlob();
                    case 'bloburi':
                    case 'bloburl':
                        // User is responsible of calling revokeObjectURL
                        return global.URL && global.URL.createObjectURL(getBlob()) || void 0;
                    case 'datauristring':
                    case 'dataurlstring':
                        return datauri;
                    case 'dataurlnewwindow':
                        var nW = global.open(datauri);
                        if (nW || typeof safari === "undefined") return nW;
                    /* pass through */
                    case 'datauri':
                    case 'dataurl':
                        return global.document.location.href = datauri;
                    default:
                        throw new Error('Output type "' + type + '" is not supported.');
                }
                // @TODO: Add different output options
            });

        switch (unit) {
            case 'pt':
                k = 1;
                break;
            case 'mm':
                k = 72 / 25.4000508;
                break;
            case 'cm':
                k = 72 / 2.54000508;
                break;
            case 'in':
                k = 72;
                break;
            case 'px':
                k = 96 / 72;
                break;
            case 'pc':
                k = 12;
                break;
            case 'em':
                k = 12;
                break;
            case 'ex':
                k = 6;
                break;
            default:
                throw ('Invalid unit: ' + unit);
        }

        //---------------------------------------
        // Public API

        /**
         * Object exposing internal API to plugins
         * @public
         */
        API.internal = {
            'pdfEscape': pdfEscape,
            'getStyle': getStyle,
            /**
             * Returns {FontObject} describing a particular font.
             * @public
             * @function
             * @param {String} fontName (Optional) Font's family name
             * @param {String} fontStyle (Optional) Font's style variation name (Example:"Italic")
             * @returns {FontObject}
             */
            'getFont': function () {
                return fonts[getFont.apply(API, arguments)];
            },
            'getFontSize': function () {
                return activeFontSize;
            },
            'getLineHeight': function () {
                return activeFontSize * lineHeightProportion;
            },
            'write': function (string1 /*, string2, string3, etc */) {
                out(arguments.length === 1 ? string1 : Array.prototype.join.call(arguments, ' '));
            },
            'getCoordinateString': function (value) {
                return f2(value);
            },
            'getVerticalCoordinateString': function (value) {
                return f2(value);
            },
            'collections': {},
            'newObject': newObject,
            'newAdditionalObject': newAdditionalObject,
            'newObjectDeferred': newObjectDeferred,
            'newObjectDeferredBegin': newObjectDeferredBegin,
            'putStream': putStream,
            'events': events,
            // ratio that you use in multiplication of a given "size" number to arrive to 'point'
            // units of measurement.
            // scaleFactor is set at initialization of the document and calculated against the stated
            // default measurement units for the document.
            // If default is "mm", k is the number that will turn number in 'mm' into 'points' number.
            // through multiplication.
            'scaleFactor': k,
            'pageSize': {
                get width() {
                    return pageWidth
                },
                get height() {
                    return pageHeight
                }
            },
            'output': function (type, options) {
                return output(type, options);
            },
            'getNumberOfPages': function () {
                return pages.length - 1;
            },
            'pages': pages,
            'out': out,
            'f2': f2,
            'getPageInfo': function (pageNumberOneBased) {
                var objId = (pageNumberOneBased - 1) * 2 + 3;
                return {objId: objId, pageNumber: pageNumberOneBased, pageContext: pagesContext[pageNumberOneBased]};
            },
            'getCurrentPageInfo': function () {
                var objId = (currentPage - 1) * 2 + 3;
                return {objId: objId, pageNumber: currentPage, pageContext: pagesContext[currentPage]};
            },
            'getPDFVersion': function () {
                return pdfVersion;
            }
        };

        /**
         * An object representing a pdf graphics state.
         * @param parameters A parameter object that contains all properties this graphics state wants to set.
         * Supported are: opacity
         * @constructor
         */
        API.GState = function (parameters) {
            var supported = "opacity";
            for (var p in parameters) {
                if (parameters.hasOwnProperty(p) && supported.indexOf(p) >= 0) {
                    this[p] = parameters[p];
                }
            }
            this.id = ""; // set by addGState()
            this.objectNumber = -1; // will be set by putGState()

            this.equals = function (other) {
                var ignore = "id,objectNumber,equals";
                if (!other || typeof other !== typeof this)
                    return false;
                var count = 0;
                for (var p in this) {
                    if (ignore.indexOf(p) >= 0)
                        continue;
                    if (this.hasOwnProperty(p) && !other.hasOwnProperty(p))
                        return false;
                    if (this[p] !== other[p])
                        return false;
                    count++;
                }
                for (var p in other) {
                    if (other.hasOwnProperty(p) && ignore.indexOf(p) < 0)
                        count--;
                }
                return count === 0;
            }
        };

        /**
         * Adds a new {@link GState} for later use {@see setGState}.
         * @param {String} key
         * @param {GState} gState
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name addGState
         */
        API.addGState = function (key, gState) {
            addGState(key, gState);
            return this;
        };

        /**
         * Adds (and transfers the focus to) new page to the PDF document.
         * @function
         * @returns {jsPDF}
         *
         * @methodOf jsPDF#
         * @name addPage
         */
        API.addPage = function () {
            _addPage.apply(this, arguments);
            return this;
        };
        API.setPage = function () {
            _setPage.apply(this, arguments);
            return this;
        };
        API.insertPage = function (beforePage) {
            this.addPage();
            this.movePage(currentPage, beforePage);
            return this;
        };
        API.movePage = function (targetPage, beforePage) {
            var tmpPagesContext, tmpPagedim, tmpPages, i;
            if (targetPage > beforePage) {
                tmpPages = pages[targetPage];
                tmpPagedim = pagedim[targetPage];
                tmpPagesContext = pagesContext[targetPage];
                for (i = targetPage; i > beforePage; i--) {
                    pages[i] = pages[i - 1];
                    pagedim[i] = pagedim[i - 1];
                    pagesContext[i] = pagesContext[i - 1];
                }
                pages[beforePage] = tmpPages;
                pagedim[beforePage] = tmpPagedim;
                pagesContext[beforePage] = tmpPagesContext;
                this.setPage(beforePage);
            } else if (targetPage < beforePage) {
                tmpPages = pages[targetPage];
                tmpPagedim = pagedim[targetPage];
                tmpPagesContext = pagesContext[targetPage];
                for (i = targetPage; i < beforePage; i++) {
                    pages[i] = pages[i + 1];
                    pagedim[i] = pagedim[i + 1];
                    pagesContext[i] = pagesContext[i + 1];
                }
                pages[beforePage] = tmpPages;
                pagedim[beforePage] = tmpPagedim;
                pagesContext[beforePage] = tmpPagesContext;
                this.setPage(beforePage);
            }
            return this;
        };

        API.deletePage = function () {
            _deletePage.apply(this, arguments);
            return this;
        };
        API.setDisplayMode = function (zoom, layout, pmode) {
            zoomMode = zoom;
            layoutMode = layout;
            pageMode = pmode;
            return this;
        };

        /**
         * Saves the current graphics state ("pushes it on the stack"). It can be restored by {@link restoreGraphicsState}
         * later. Here, the general pdf graphics state is meant, also including the current transformation matrix,
         * fill and stroke colors etc.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name saveGraphicsState
         */
        API.saveGraphicsState = function () {
            out("q");
            // as we cannot set font key and size independently we must keep track of both
            fontStateStack.push({
                key: activeFontKey,
                size: activeFontSize
            });
            return this;
        };

        /**
         * Restores a previously saved graphics state saved by {@link saveGraphicsState} ("pops the stack").
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name restoreGraphicsState
         */
        API.restoreGraphicsState = function () {
            out("Q");

            // restore previous font state
            var fontState = fontStateStack.pop();
            activeFontKey = fontState.key;
            activeFontSize = fontState.size;

            return this;
        };

        /**
         * Appends this matrix to the left of all previously applied matrices.
         * @param {Matrix} matrix
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setCurrentTransformationMatrix
         */
        API.setCurrentTransformationMatrix = function (matrix) {
            out(matrix.toString() + " cm");
            return this;
        };

        /**
         * Starts a new pdf form object, which means that all conseequent draw calls target a new independent object
         * until {@link endFormObject} is called. The created object can be referenced and drawn later using
         * {@link doFormObject}. Nested form objects are possible.
         * x, y, width, height set the bounding box that is used to clip the content.
         * @param {number} x
         * @param {number} y
         * @param {number} width
         * @param {number} height
         * @param {Matrix} matrix The matrix that will be applied to convert the form objects coordinate system to
         * the parent's.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         */
        API.beginFormObject = function (x, y, width, height, matrix) {
            // The user can set the output target to a new form object. Nested form objects are possible.
            // Currently, they use the resource dictionary of the surrounding stream. This should be changed, as
            // the PDF-Spec states:
            // "In PDF 1.2 and later versions, form XObjects may be independent of the content streams in which
            // they appear, and this is strongly recommended although not requiredIn PDF 1.2 and later versions,
            // form XObjects may be independent of the content streams in which they appear, and this is strongly
            // recommended although not required"
            beginNewRenderTarget(x, y, width, height, matrix);
            return this;
        };

        /**
         * Completes and saves the form object.
         * @param {String} key The key by which this form object can be referenced.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name endFormObject
         */
        API.endFormObject = function (key) {
            endFormObject(key);
            return this;
        };

        /**
         * Draws the specified form object by referencing to the respective pdf XObject created with
         * {@link API.beginFormObject} and {@link endFormObject}.
         * The location is determined by matrix.
         * @param {String} key The key to the form object.
         * @param {Matrix} matrix The matrix applied before drawing the form object.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name doFormObject
         */
        API.doFormObject = function (key, matrix) {
            var xObject = renderTargets[renderTargetMap[key]];
            out("q");
            out(matrix.toString() + " cm");
            out("/" + xObject.id + " Do");
            out("Q");
            return this;
        };

        /**
         * Returns the form object specified by key.
         * @param key {String}
         * @returns {{x: number, y: number, width: number, height: number, matrix: Matrix}}
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name getFormObject
         */
        API.getFormObject = function (key) {
            var xObject = renderTargets[renderTargetMap[key]];
            return {
                x: xObject.x,
                y: xObject.y,
                width: xObject.width,
                height: xObject.height,
                matrix: xObject.matrix
            };
        };

        /**
         * A matrix object for 2D homogenous transformations:
         * | a b 0 |
         * | c d 0 |
         * | e f 1 |
         * pdf multiplies matrices righthand: v' = v x m1 x m2 x ...
         * @param {number} a
         * @param {number} b
         * @param {number} c
         * @param {number} d
         * @param {number} e
         * @param {number} f
         * @constructor
         */
        API.Matrix = Matrix;

        /**
         * Multiplies two matrices. (see {@link Matrix})
         * @param {Matrix} m1
         * @param {Matrix} m2
         */
        API.matrixMult = matrixMult;

        /**
         * The unit matrix (equal to new Matrix(1, 0, 0, 1, 0, 0).
         * @type {Matrix}
         */
        API.unitMatrix = unitMatrix;

        var Pattern = function (gState, matrix) {
            this.gState = gState;
            this.matrix = matrix;

            this.id = ""; // set by addPattern()
            this.objectNumber = -1; // will be set by putPattern()
        };

        /**
         * A pattern describing a shading pattern.
         * @param {String} type One of "axial" or "radial"
         * @param {Array<Number>} coords Either [x1, y1, x2, y2] for "axial" type describing the two interpolation points
         * or [x1, y1, r, x2, y2, r2] for "radial" describing inner and the outer circle.
         * @param {Array<Object>} colors An array of objects with the fields "offset" and "color". "offset" describes
         * the offset in parameter space [0, 1]. "color" is an array of length 3 describing RGB values in [0, 255].
         * @param {GState=} gState An additional graphics state that gets applied to the pattern (optional).
         * @param {Matrix=} matrix A matrix that describes the transformation between the pattern coordinate system
         * and the use coordinate system (optional).
         * @constructor
         * @extends API.Pattern
         */
        API.ShadingPattern = function (type, coords, colors, gState, matrix) {
            // see putPattern() for information how they are realized
            this.type = type === "axial" ? 2 : 3;
            this.coords = coords;
            this.colors = colors;

            Pattern.call(this, gState, matrix);
        };

        /**
         * A PDF Tiling pattern.
         * @param {Array.<Number>} boundingBox The bounding box at which one pattern cell gets clipped.
         * @param {Number} xStep Horizontal spacing between pattern cells.
         * @param {Number} yStep Vertical spacing between pattern cells.
         * @param {API.GState=} gState An additional graphics state that gets applied to the pattern (optional).
         * @param {Matrix=} matrix A matrix that describes the transformation between the pattern coordinate system
         * and the use coordinate system (optional).
         * @constructor
         * @extends API.Pattern
         */
        API.TilingPattern = function (boundingBox, xStep, yStep, gState, matrix) {
            this.boundingBox = boundingBox;
            this.xStep = xStep;
            this.yStep = yStep;

            this.stream = ""; // set by endTilingPattern();

            this.cloneIndex = 0;

            Pattern.call(this, gState, matrix);
        };

        API.TilingPattern.prototype = {
            createClone: function (patternKey, boundingBox, xStep, yStep, matrix) {
                var clone = new API.TilingPattern(boundingBox || this.boundingBox, xStep || this.xStep, yStep || this.yStep,
                    this.gState, matrix || this.matrix);
                clone.stream = this.stream;
                var key = patternKey + "$$" + this.cloneIndex++ + "$$";
                addPattern(key, clone);
                return clone;
            }
        };

        /**
         * Adds a new {@link API.ShadingPattern} for later use.
         * @param {String} key
         * @param {Pattern} pattern
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name addPattern
         */
        API.addShadingPattern = function (key, pattern) {
            addPattern(key, pattern);
            return this;
        };

        /**
         * Begins a new tiling pattern. All subsequent render calls are drawn to this pattern until {@link API.endTilingPattern}
         * gets called.
         * @param {API.Pattern} pattern
         */
        API.beginTilingPattern = function (pattern) {
            beginNewRenderTarget(pattern.boundingBox[0], pattern.boundingBox[1],
                pattern.boundingBox[2] - pattern.boundingBox[0], pattern.boundingBox[3] - pattern.boundingBox[1], pattern.matrix);
        };

        /**
         * Ends a tiling pattern and sets the render target to the one active before {@link API.beginTilingPattern} has been called.
         * @param {string} key A unique key that is used to reference this pattern at later use.
         * @param {API.Pattern} pattern The pattern to end.
         */
        API.endTilingPattern = function (key, pattern) {
            // retrieve the stream
            pattern.stream = pages[currentPage].join("\n");

            addPattern(key, pattern);

            events.publish("endTilingPattern", pattern);

            // restore state from stack
            renderTargetStack.pop().restore();
        };

        /**
         * Adds text to page. Supports adding multiline text when 'text' argument is an Array of Strings.
         *
         * @function
         * @param {String|Array} text String or array of strings to be added to the page. Each line is shifted one line down
         * per font, spacing settings declared before this call.
         * @param {Number} x Coordinate (in units declared at inception of PDF document) against left edge of the page
         * @param {Number} y Coordinate (in units declared at inception of PDF document) against upper edge of the page
         * @param {Object} flags Collection of settings signalling how the text must be encoded. Defaults are sane. If you
         * think you want to pass some flags, you likely can read the source.
         * @param {number|Matrix} transform If transform is a number the text will be rotated by this value. If it is a Matrix,
         * this matrix gets directly applied to the text, which allows shearing effects etc.
         * @param align {string}
         * @returns {jsPDF}
         * @methodOf jsPDF#
         */
        API.text = function (text, x, y, flags, transform, align) {
            /**
             * Inserts something like this into PDF
             *   BT
             *    /F1 16 Tf  % Font name + size
             *    16 TL % How many units down for next line in multiline text
             *    0 g % color
             *    28.35 813.54 Td % position
             *    (line one) Tj
             *    T* (line two) Tj
             *    T* (line three) Tj
             *   ET
             */
            function ESC(s) {
                s = s.split("\t").join(Array(options.TabLen || 9).join(" "));
                return pdfEscape(s, flags);
            }

            // Pre-August-2012 the order of arguments was function(x, y, text, flags)
            // in effort to make all calls have similar signature like
            //   function(data, coordinates... , miscellaneous)
            // this method had its args flipped.
            // code below allows backward compatibility with old arg order.
            if (typeof text === 'number') {
                var tmp = y;
                y = x;
                x = text;
                text = tmp;
            }

            // If there are any newlines in text, we assume
            // the user wanted to print multiple lines, so break the
            // text up into an array.  If the text is already an array,
            // we assume the user knows what they are doing.
            // Convert text into an array anyway to simplify
            // later code.
            if (typeof text === 'string') {
                if (text.match(/[\n\r]/)) {
                    text = text.split(/\r\n|\r|\n/g);
                } else {
                    text = [text];
                }
            }
            if (typeof transform === 'string') {
                align = transform;
                transform = null;
            }
            if (typeof flags === 'string') {
                align = flags;
                flags = null;
            }
            if (typeof flags === 'number') {
                transform = flags;
                flags = null;
            }

            var todo;
            if (transform && typeof transform === "number") {
                transform *= (Math.PI / 180);
                var c = Math.cos(transform),
                    s = Math.sin(transform);
                transform = new Matrix(c, s, -s, c, 0, 0);
            } else if (!transform) {
                transform = unitMatrix;
            }

            flags = flags || {};
            if (!('noBOM' in flags))
                flags.noBOM = true;
            if (!('autoencode' in flags))
                flags.autoencode = true;

            var strokeOption = '';
            var pageContext = this.internal.getCurrentPageInfo().pageContext;
            if (true === flags.stroke) {
                if (pageContext.lastTextWasStroke !== true) {
                    strokeOption = '1 Tr\n';
                    pageContext.lastTextWasStroke = true;
                }
            } else {
                if (pageContext.lastTextWasStroke) {
                    strokeOption = '0 Tr\n';
                }
                pageContext.lastTextWasStroke = false;
            }

            if (typeof this._runningPageHeight === 'undefined') {
                this._runningPageHeight = 0;
            }

            if (typeof text === 'string') {
                text = ESC(text);
            } else if (Object.prototype.toString.call(text) === '[object Array]') {
                // we don't want to destroy  original text array, so cloning it
                var sa = text.concat(), da = [], len = sa.length;
                // we do array.join('text that must not be PDFescaped")
                // thus, pdfEscape each component separately
                while (len--) {
                    da.push(ESC(sa.shift()));
                }
                var linesLeft = Math.ceil((y - this._runningPageHeight) / (activeFontSize * lineHeightProportion));
                if (0 <= linesLeft && linesLeft < da.length + 1) {
                    //todo = da.splice(linesLeft-1);
                }

                if (align) {
                    var left,
                        prevX,
                        maxLineLength,
                        leading = activeFontSize * lineHeightProportion,
                        lineWidths = text.map(function (v) {
                            return this.getStringUnitWidth(v) * activeFontSize;
                        }, this);
                    maxLineLength = Math.max.apply(Math, lineWidths);
                    // The first line uses the "main" Td setting,
                    // and the subsequent lines are offset by the
                    // previous line's x coordinate.
                    if (align === "center") {
                        // The passed in x coordinate defines
                        // the center point.
                        left = x - maxLineLength / 2;
                        x -= lineWidths[0] / 2;
                    } else if (align === "right") {
                        // The passed in x coordinate defines the
                        // rightmost point of the text.
                        left = x - maxLineLength;
                        x -= lineWidths[0];
                    } else {
                        throw new Error('Unrecognized alignment option, use "center" or "right".');
                    }
                    prevX = x;
                    text = da[0] + ") Tj\n";
                    for (i = 1, len = da.length; i < len; i++) {
                        var delta = maxLineLength - lineWidths[i];
                        if (align === "center") delta /= 2;
                        // T* = x-offset leading Td ( text )
                        text += ((left - prevX) + delta) + " -" + leading + " Td (" + da[i];
                        prevX = left + delta;
                        if (i < len - 1) {
                            text += ") Tj\n";
                        }
                    }
                } else {
                    text = da.join(") Tj\nT* (");
                }
            } else {
                throw new Error('Type of text must be string or Array. "' + text + '" is not recognized.');
            }
            // Using "'" ("go next line and render text" mark) would save space but would complicate our rendering code, templates

            // BT .. ET does NOT have default settings for Tf. You must state that explicitely every time for BT .. ET
            // if you want text transformation matrix (+ multiline) to work reliably (which reads sizes of things from font declarations)
            // Thus, there is NO useful, *reliable* concept of "default" font for a page.
            // The fact that "default" (reuse font used before) font worked before in basic cases is an accident
            // - readers dealing smartly with brokenness of jsPDF's markup.

            var curY;

            if (todo) {
                //this.addPage();
                //this._runningPageHeight += y -  (activeFontSize * 1.7);
                //curY = f2(activeFontSize * 1.7);
            } else {
                curY = f2(y);
            }
            //curY = f2(((y - this._runningPageHeight));

//			if (curY < 0){
//				console.log('auto page break');
//				this.addPage();
//				this._runningPageHeight = y -  (activeFontSize * 1.7);
//				curY = f2(activeFontSize * 1.7);
//			}

            var translate = new Matrix(1, 0, 0, -1, x, curY);
            transform = matrixMult(translate, transform);
            var position = transform.toString() + " Tm";

            out(
                'BT\n' +
                (activeFontSize * lineHeightProportion) + ' TL\n' +  // line spacing
                strokeOption +// stroke option
                position + '\n(' +
                text +
                ') Tj\nET');

            if (todo) {
                //this.text( todo, x, activeFontSize * 1.7);
                //this.text( todo, x, this._runningPageHeight + (activeFontSize * 1.7));
                this.text(todo, x, y);// + (activeFontSize * 1.7));
            }

            return this;
        };


        API.lstext = function (text, x, y, spacing) {
            for (var i = 0, len = text.length; i < len; i++, x += spacing) this.text(text[i], x, y);
        };

        /**
         * Draw a line
         * @param {number} x1
         * @param {number} y1
         * @param {number} x2
         * @param {number} y2
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name line
         */
        API.line = function (x1, y1, x2, y2) {
            return this.lines([[x2 - x1, y2 - y1]], x1, y1, [1, 1], "D");
        };

        API.clip = function () {
            // By patrick-roberts, github.com/MrRio/jsPDF/issues/328
            // Call .clip() after calling .rect() with a style argument of null
            out('W'); // clip
            out('S'); // stroke path; necessary for clip to work
        };


        /**
         * @typedef {Object} PatternData
         * {Matrix|undefined} matrix
         * {Number|undefined} xStep
         * {Number|undefined} yStep
         * {Array.<Number>|undefined} boundingBox
         */

        /**
         * Adds series of curves (straight lines or cubic bezier curves) to canvas, starting at `x`, `y` coordinates.
         * All data points in `lines` are relative to last line origin.
         * `x`, `y` become x1,y1 for first line / curve in the set.
         * For lines you only need to specify [x2, y2] - (ending point) vector against x1, y1 starting point.
         * For bezier curves you need to specify [x2,y2,x3,y3,x4,y4] - vectors to control points 1, 2, ending point. All vectors are against the start of the curve - x1,y1.
         *
         * @example .lines([[2,2],[-2,2],[1,1,2,2,3,3],[2,1]], 212,110, 10) // line, line, bezier curve, line
         * @param {Array} lines Array of *vector* shifts as pairs (lines) or sextets (cubic bezier curves).
         * @param {Number} x Coordinate (in units declared at inception of PDF document) against left edge of the page
         * @param {Number} y Coordinate (in units declared at inception of PDF document) against upper edge of the page
         * @param {Number} scale (Defaults to [1.0,1.0]) x,y Scaling factor for all vectors. Elements can be any floating number Sub-one makes drawing smaller. Over-one grows the drawing. Negative flips the direction.
         * @param {String} style A string specifying the painting style or null.  Valid styles include: 'S' [default] - stroke, 'F' - fill,  and 'DF' (or 'FD') -  fill then stroke. A null value postpones setting the style so that a shape may be composed using multiple method calls. The last drawing method call used to define the shape should not have a null style argument.
         * @param {Boolean} closed If true, the path is closed with a straight line from the end of the last curve to the starting point.
         * @param {String} patternKey The pattern key for the pattern that should be used to fill the path.
         * @param {Matrix|PatternData} patternData The matrix that transforms the pattern into user space, or an object that
         * will modify the pattern on use.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name lines
         */
        API.lines = function (lines, x, y, scale, style, closed, patternKey, patternData) {
            var scalex, scaley, i, l, leg, x2, y2, x3, y3, x4, y4;

            // Pre-August-2012 the order of arguments was function(x, y, lines, scale, style)
            // in effort to make all calls have similar signature like
            //   function(content, coordinateX, coordinateY , miscellaneous)
            // this method had its args flipped.
            // code below allows backward compatibility with old arg order.
            if (typeof lines === 'number') {
                var tmp = y;
                y = x;
                x = lines;
                lines = tmp;
            }

            scale = scale || [1, 1];

            // starting point
            out(f3(x) + ' ' + f3(y) + ' m ');

            scalex = scale[0];
            scaley = scale[1];
            l = lines.length;
            //, x2, y2 // bezier only. In page default measurement "units", *after* scaling
            //, x3, y3 // bezier only. In page default measurement "units", *after* scaling
            // ending point for all, lines and bezier. . In page default measurement "units", *after* scaling
            x4 = x; // last / ending point = starting point for first item.
            y4 = y; // last / ending point = starting point for first item.

            for (i = 0; i < l; i++) {
                leg = lines[i];
                if (leg.length === 2) {
                    // simple line
                    x4 = leg[0] * scalex + x4; // here last x4 was prior ending point
                    y4 = leg[1] * scaley + y4; // here last y4 was prior ending point
                    out(f3(x4) + ' ' + f3(y4) + ' l');
                } else {
                    // bezier curve
                    x2 = leg[0] * scalex + x4; // here last x4 is prior ending point
                    y2 = leg[1] * scaley + y4; // here last y4 is prior ending point
                    x3 = leg[2] * scalex + x4; // here last x4 is prior ending point
                    y3 = leg[3] * scaley + y4; // here last y4 is prior ending point
                    x4 = leg[4] * scalex + x4; // here last x4 was prior ending point
                    y4 = leg[5] * scaley + y4; // here last y4 was prior ending point
                    out(
                        f3(x2) + ' ' +
                        f3(y2) + ' ' +
                        f3(x3) + ' ' +
                        f3(y3) + ' ' +
                        f3(x4) + ' ' +
                        f3(y4) + ' c');
                }
            }

            if (closed) {
                out('h');
            }

            putStyle(style, patternKey, patternData);

            return this;
        };

        /**
         * Similar to {@link API.lines} but all coordinates are interpreted as absolute coordinates instead of relative.
         * @param {Array<Object>} lines An array of {op: operator, c: coordinates} object, where op is one of "m" (move to), "l" (line to)
         * "c" (cubic bezier curve) and "h" (close (sub)path)). c is an array of coordinates. "m" and "l" expect two, "c"
         * six and "h" an empty array (or undefined).
         * @param {String} style  The style
         * @param {String} patternKey The pattern key for the pattern that should be used to fill the path.
         * @param {Matrix|PatternData} patternData The matrix that transforms the pattern into user space, or an object that
         * will modify the pattern on use.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name path
         */
        API.path = function (lines, style, patternKey, patternData) {

            for (var i = 0; i < lines.length; i++) {
                var leg = lines[i];
                var coords = leg.c;
                switch (leg.op) {
                    case "m":
                        // move
                        out(f3(coords[0]) + ' ' + f3(coords[1]) + ' m');
                        break;
                    case "l":
                        // simple line
                        out(f3(coords[0]) + ' ' + f3(coords[1]) + ' l');
                        break;
                    case "c":
                        // bezier curve
                        out([
                            f3(coords[0]),
                            f3(coords[1]),
                            f3(coords[2]),
                            f3(coords[3]),
                            f3(coords[4]),
                            f3(coords[5]),
                            "c"
                        ].join(" "));
                        break;
                    case "h":
                        // close path
                        out("h");
                }


            }

            putStyle(style, patternKey, patternData);

            return this;
        };

        /**
         * Adds a rectangle to PDF
         *
         * @param {Number} x Coordinate (in units declared at inception of PDF document) against left edge of the page
         * @param {Number} y Coordinate (in units declared at inception of PDF document) against upper edge of the page
         * @param {Number} w Width (in units declared at inception of PDF document)
         * @param {Number} h Height (in units declared at inception of PDF document)
         * @param {String} style A string specifying the painting style or null.  Valid styles include: 'S' [default] - stroke, 'F' - fill,  and 'DF' (or 'FD') -  fill then stroke. A null value postpones setting the style so that a shape may be composed using multiple method calls. The last drawing method call used to define the shape should not have a null style argument.
         * @param {String} patternKey The pattern key for the pattern that should be used to fill the primitive.
         * @param {Matrix|PatternData} patternData The matrix that transforms the pattern into user space, or an object that
         * will modify the pattern on use.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name rect
         */
        API.rect = function (x, y, w, h, style, patternKey, patternData) {
            out([
                f2(x),
                f2(y),
                f2(w),
                f2(-h),
                're'
            ].join(' '));

            putStyle(style, patternKey, patternData);

            return this;
        };

        /**
         * Adds a triangle to PDF
         *
         * @param {Number} x1 Coordinate (in units declared at inception of PDF document) against left edge of the page
         * @param {Number} y1 Coordinate (in units declared at inception of PDF document) against upper edge of the page
         * @param {Number} x2 Coordinate (in units declared at inception of PDF document) against left edge of the page
         * @param {Number} y2 Coordinate (in units declared at inception of PDF document) against upper edge of the page
         * @param {Number} x3 Coordinate (in units declared at inception of PDF document) against left edge of the page
         * @param {Number} y3 Coordinate (in units declared at inception of PDF document) against upper edge of the page
         * @param {String} style A string specifying the painting style or null.  Valid styles include: 'S' [default] - stroke, 'F' - fill,  and 'DF' (or 'FD') -  fill then stroke. A null value postpones setting the style so that a shape may be composed using multiple method calls. The last drawing method call used to define the shape should not have a null style argument.
         * @param {String} patternKey The pattern key for the pattern that should be used to fill the primitive.
         * @param {Matrix|PatternData} patternData The matrix that transforms the pattern into user space, or an object that
         * will modify the pattern on use.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name triangle
         */
        API.triangle = function (x1, y1, x2, y2, x3, y3, style, patternKey, patternData) {
            this.lines(
                [
                    [x2 - x1, y2 - y1], // vector to point 2
                    [x3 - x2, y3 - y2], // vector to point 3
                    [x1 - x3, y1 - y3]// closing vector back to point 1
                ],
                x1,
                y1, // start of path
                [1, 1],
                style,
                true,
                patternKey,
                patternData
            );
            return this;
        };

        /**
         * Adds a rectangle with rounded corners to PDF
         *
         * @param {Number} x Coordinate (in units declared at inception of PDF document) against left edge of the page
         * @param {Number} y Coordinate (in units declared at inception of PDF document) against upper edge of the page
         * @param {Number} w Width (in units declared at inception of PDF document)
         * @param {Number} h Height (in units declared at inception of PDF document)
         * @param {Number} rx Radius along x axis (in units declared at inception of PDF document)
         * @param {Number} ry Radius along y axis (in units declared at inception of PDF document)
         * @param {String} style A string specifying the painting style or null.  Valid styles include: 'S' [default] - stroke, 'F' - fill,  and 'DF' (or 'FD') -  fill then stroke. A null value postpones setting the style so that a shape may be composed using multiple method calls. The last drawing method call used to define the shape should not have a null style argument.
         * @param {String} patternKey The pattern key for the pattern that should be used to fill the primitive.
         * @param {Matrix|PatternData} patternData The matrix that transforms the pattern into user space, or an object that
         * will modify the pattern on use.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name roundedRect
         */
        API.roundedRect = function (x, y, w, h, rx, ry, style, patternKey, patternData) {
            var MyArc = 4 / 3 * (Math.SQRT2 - 1);

            rx = Math.min(rx, w * 0.5);
            ry = Math.min(ry, h * 0.5);

            this.lines(
                [
                    [(w - 2 * rx), 0],
                    [(rx * MyArc), 0, rx, ry - (ry * MyArc), rx, ry],
                    [0, (h - 2 * ry)],
                    [0, (ry * MyArc), -(rx * MyArc), ry, -rx, ry],
                    [(-w + 2 * rx), 0],
                    [-(rx * MyArc), 0, -rx, -(ry * MyArc), -rx, -ry],
                    [0, (-h + 2 * ry)],
                    [0, -(ry * MyArc), (rx * MyArc), -ry, rx, -ry]
                ],
                x + rx,
                y, // start of path
                [1, 1],
                style,
                true,
                patternKey,
                patternData
            );
            return this;
        };

        /**
         * Adds an ellipse to PDF
         *
         * @param {Number} x Coordinate (in units declared at inception of PDF document) against left edge of the page
         * @param {Number} y Coordinate (in units declared at inception of PDF document) against upper edge of the page
         * @param {Number} rx Radius along x axis (in units declared at inception of PDF document)
         * @param {Number} ry Radius along y axis (in units declared at inception of PDF document)
         * @param {String} style A string specifying the painting style or null.  Valid styles include: 'S' [default] - stroke, 'F' - fill,  and 'DF' (or 'FD') -  fill then stroke. A null value postpones setting the style so that a shape may be composed using multiple method calls. The last drawing method call used to define the shape should not have a null style argument.
         * @param {String} patternKey The pattern key for the pattern that should be used to fill the primitive.
         * @param {Matrix|PatternData} patternData The matrix that transforms the pattern into user space, or an object that
         * will modify the pattern on use.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name ellipse
         */
        API.ellipse = function (x, y, rx, ry, style, patternKey, patternData) {
            var lx = 4 / 3 * (Math.SQRT2 - 1) * rx,
                ly = 4 / 3 * (Math.SQRT2 - 1) * ry;

            out([
                f2(x + rx),
                f2(y),
                'm',
                f2(x + rx),
                f2(y - ly),
                f2(x + lx),
                f2(y - ry),
                f2(x),
                f2(y - ry),
                'c'
            ].join(' '));
            out([
                f2(x - lx),
                f2(y - ry),
                f2(x - rx),
                f2(y - ly),
                f2(x - rx),
                f2(y),
                'c'
            ].join(' '));
            out([
                f2(x - rx),
                f2(y + ly),
                f2(x - lx),
                f2(y + ry),
                f2(x),
                f2(y + ry),
                'c'
            ].join(' '));
            out([
                f2(x + lx),
                f2(y + ry),
                f2(x + rx),
                f2(y + ly),
                f2(x + rx),
                f2(y),
                'c'
            ].join(' '));

            putStyle(style, patternKey, patternData);

            return this;
        };

        /**
         * Adds an circle to PDF
         *
         * @param {Number} x Coordinate (in units declared at inception of PDF document) against left edge of the page
         * @param {Number} y Coordinate (in units declared at inception of PDF document) against upper edge of the page
         * @param {Number} r Radius (in units declared at inception of PDF document)
         * @param {String} style A string specifying the painting style or null.  Valid styles include: 'S' [default] - stroke, 'F' - fill,  and 'DF' (or 'FD') -  fill then stroke. A null value postpones setting the style so that a shape may be composed using multiple method calls. The last drawing method call used to define the shape should not have a null style argument.
         * @param {String} patternKey The pattern key for the pattern that should be used to fill the primitive.
         * @param {Matrix|PatternData} patternData The matrix that transforms the pattern into user space, or an object that
         * will modify the pattern on use.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name circle
         */
        API.circle = function (x, y, r, style, patternKey, patternData) {
            return this.ellipse(x, y, r, r, style, patternKey, patternData);
        };

        /**
         * Adds a properties to the PDF document
         *
         * @param {Object} properties A property_name-to-property_value object structure.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setProperties
         */
        API.setProperties = function (properties) {
            // copying only those properties we can render.
            for (var property in documentProperties) {
                if (documentProperties.hasOwnProperty(property) && properties[property]) {
                    documentProperties[property] = properties[property];
                }
            }
            return this;
        };

        /**
         * Sets font size for upcoming text elements.
         *
         * @param {Number} size Font size in points.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setFontSize
         */
        API.setFontSize = function (size) {
            activeFontSize = size;
            out("/" + activeFontKey + " " + activeFontSize + " Tf");
            return this;
        };

        API.getFontSize = function () {
            return activeFontSize;
        };

        /**
         * Sets text font face, variant for upcoming text elements.
         * See output of jsPDF.getFontList() for possible font names, styles.
         *
         * @param {String} fontName Font name or family. Example: "times"
         * @param {String} fontStyle Font style or variant. Example: "italic"
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setFont
         */
        API.setFont = function (fontName, fontStyle) {
            activeFontKey = getFont(fontName, fontStyle);
            // if font is not found, the above line blows up and we never go further
            out("/" + activeFontKey + " " + activeFontSize + " Tf");
            return this;
        };

        /**
         * Switches font style or variant for upcoming text elements,
         * while keeping the font face or family same.
         * See output of jsPDF.getFontList() for possible font names, styles.
         *
         * @param {String} style Font style or variant. Example: "italic"
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setFontStyle
         */
        API.setFontStyle = API.setFontType = function (style) {
            activeFontKey = getFont(undefined, style);
            // if font is not found, the above line blows up and we never go further
            return this;
        };

        /**
         * Returns an object - a tree of fontName to fontStyle relationships available to
         * active PDF document.
         *
         * @public
         * @function
         * @returns {Object} Like {'times':['normal', 'italic', ... ], 'arial':['normal', 'bold', ... ], ... }
         * @methodOf jsPDF#
         * @name getFontList
         */
        API.getFontList = function () {
            // TODO: iterate over fonts array or return copy of fontmap instead in case more are ever added.
            var list = {}, fontName, fontStyle, tmp;

            for (fontName in fontmap) {
                if (fontmap.hasOwnProperty(fontName)) {
                    list[fontName] = tmp = [];
                    for (fontStyle in fontmap[fontName]) {
                        if (fontmap[fontName].hasOwnProperty(fontStyle)) {
                            tmp.push(fontStyle);
                        }
                    }
                }
            }

            return list;
        };

        /**
         * Add a custom font.
         *
         * @param {String} postScriptName name of the Font.  Example: "Menlo-Regular"
         * @param {String} fontName of font-family from @font-face definition.  Example: "Menlo Regular"
         * @param {String} fontStyle style.  Example: "normal"
         * @function
         * @returns the {fontKey} (same as the internal method)
         * @methodOf jsPDF#
         * @name addFont
         */
        API.addFont = function (postScriptName, fontName, fontStyle) {
            addFont(postScriptName, fontName, fontStyle, 'StandardEncoding');
        };

        /**
         * Sets line width for upcoming lines.
         *
         * @param {Number} width Line width (in units declared at inception of PDF document)
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setLineWidth
         */
        API.setLineWidth = function (width) {
            out(width.toFixed(2) + ' w');
            return this;
        };

        /**
         * Sets the stroke color for upcoming elements.
         *
         * Depending on the number of arguments given, Gray, RGB, or CMYK
         * color space is implied.
         *
         * When only ch1 is given, "Gray" color space is implied and it
         * must be a value in the range from 0.00 (solid black) to to 1.00 (white)
         * if values are communicated as String types, or in range from 0 (black)
         * to 255 (white) if communicated as Number type.
         * The RGB-like 0-255 range is provided for backward compatibility.
         *
         * When only ch1,ch2,ch3 are given, "RGB" color space is implied and each
         * value must be in the range from 0.00 (minimum intensity) to to 1.00
         * (max intensity) if values are communicated as String types, or
         * from 0 (min intensity) to to 255 (max intensity) if values are communicated
         * as Number types.
         * The RGB-like 0-255 range is provided for backward compatibility.
         *
         * When ch1,ch2,ch3,ch4 are given, "CMYK" color space is implied and each
         * value must be a in the range from 0.00 (0% concentration) to to
         * 1.00 (100% concentration)
         *
         * Because JavaScript treats fixed point numbers badly (rounds to
         * floating point nearest to binary representation) it is highly advised to
         * communicate the fractional numbers as String types, not JavaScript Number type.
         *
         * @param {Number|String} ch1 Color channel value
         * @param {Number|String} ch2 Color channel value
         * @param {Number|String} ch3 Color channel value
         * @param {Number|String} ch4 Color channel value
         *
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setDrawColor
         */
        API.setDrawColor = function (ch1, ch2, ch3, ch4) {
            var color;
            if (ch2 === undefined || (ch4 === undefined && ch1 === ch2 === ch3)) {
                // Gray color space.
                if (typeof ch1 === 'string') {
                    color = ch1 + ' G';
                } else {
                    color = f2(ch1 / 255) + ' G';
                }
            } else if (ch4 === undefined) {
                // RGB
                if (typeof ch1 === 'string') {
                    color = [ch1, ch2, ch3, 'RG'].join(' ');
                } else {
                    color = [f2(ch1 / 255), f2(ch2 / 255), f2(ch3 / 255), 'RG'].join(' ');
                }
            } else {
                // CMYK
                if (typeof ch1 === 'string') {
                    color = [ch1, ch2, ch3, ch4, 'K'].join(' ');
                } else {
                    color = [f2(ch1), f2(ch2), f2(ch3), f2(ch4), 'K'].join(' ');
                }
            }

            out(color);
            return this;
        };

        /**
         * Sets the fill color for upcoming elements.
         *
         * Depending on the number of arguments given, Gray, RGB, or CMYK
         * color space is implied.
         *
         * When only ch1 is given, "Gray" color space is implied and it
         * must be a value in the range from 0.00 (solid black) to to 1.00 (white)
         * if values are communicated as String types, or in range from 0 (black)
         * to 255 (white) if communicated as Number type.
         * The RGB-like 0-255 range is provided for backward compatibility.
         *
         * When only ch1,ch2,ch3 are given, "RGB" color space is implied and each
         * value must be in the range from 0.00 (minimum intensity) to to 1.00
         * (max intensity) if values are communicated as String types, or
         * from 0 (min intensity) to to 255 (max intensity) if values are communicated
         * as Number types.
         * The RGB-like 0-255 range is provided for backward compatibility.
         *
         * When ch1,ch2,ch3,ch4 are given, "CMYK" color space is implied and each
         * value must be a in the range from 0.00 (0% concentration) to to
         * 1.00 (100% concentration)
         *
         * Because JavaScript treats fixed point numbers badly (rounds to
         * floating point nearest to binary representation) it is highly advised to
         * communicate the fractional numbers as String types, not JavaScript Number type.
         *
         * @param {Number|String} ch1 Color channel value
         * @param {Number|String} ch2 Color channel value
         * @param {Number|String} ch3 Color channel value
         * @param {Number|String} ch4 Color channel value
         *
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setFillColor
         */
        API.setFillColor = function (ch1, ch2, ch3, ch4) {
            var color;

            if (ch2 === undefined || (ch4 === undefined && ch1 === ch2 === ch3)) {
                // Gray color space.
                if (typeof ch1 === 'string') {
                    color = ch1 + ' g';
                } else {
                    color = f2(ch1 / 255) + ' g';
                }
            } else if (ch4 === undefined || typeof ch4 === 'object') {
                // RGB
                if (typeof ch1 === 'string') {
                    color = [ch1, ch2, ch3, 'rg'].join(' ');
                } else {
                    color = [f2(ch1 / 255), f2(ch2 / 255), f2(ch3 / 255), 'rg'].join(' ');
                }
                if (ch4 && ch4.a === 0) {
                    //TODO Implement transparency.
                    //WORKAROUND use white for now
                    color = ['255', '255', '255', 'rg'].join(' ');
                }
            } else {
                // CMYK
                if (typeof ch1 === 'string') {
                    color = [ch1, ch2, ch3, ch4, 'k'].join(' ');
                } else {
                    color = [f2(ch1), f2(ch2), f2(ch3), f2(ch4), 'k'].join(' ');
                }
            }

            out(color);
            return this;
        };

        /**
         * Sets the text color for upcoming elements.
         * If only one, first argument is given,
         * treats the value as gray-scale color value.
         *
         * @param {Number} r Red channel color value in range 0-255 or {String} r color value in hexadecimal, example: '#FFFFFF'
         * @param {Number} g Green channel color value in range 0-255
         * @param {Number} b Blue channel color value in range 0-255
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setTextColor
         */
        API.setTextColor = function (r, g, b) {
            if ((typeof r === 'string') && /^#[0-9A-Fa-f]{6}$/.test(r)) {
                var hex = parseInt(r.substr(1), 16);
                r = (hex >> 16) & 255;
                g = (hex >> 8) & 255;
                b = (hex & 255);
            }

            if ((r === 0 && g === 0 && b === 0) || (typeof g === 'undefined')) {
                textColor = f3(r / 255) + ' g';
            } else {
                textColor = [f3(r / 255), f3(g / 255), f3(b / 255), 'rg'].join(' ');
            }

            out(textColor);

            return this;
        };

        /**
         * Sets a either previously added {@link GState} (via {@link addGState}) or a new {@link GState}.
         * @param {String|GState} gState If type is string, a previously added GState is used, if type is GState
         * it will be added before use.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setGState
         */
        API.setGState = function (gState) {
            if (typeof gState === "string") {
                gState = gStates[gStatesMap[gState]];
            } else {
                gState = addGState(null, gState);
            }

            if (!gState.equals(activeGState)) {
                out("/" + gState.id + " gs");
                activeGState = gState;
            }
        };

        /**
         * Is an Object providing a mapping from human-readable to
         * integer flag values designating the varieties of line cap
         * and join styles.
         *
         * @returns {Object}
         * @fieldOf jsPDF#
         * @name CapJoinStyles
         */
        API.CapJoinStyles = {
            0: 0,
            'butt': 0,
            'but': 0,
            'miter': 0,
            1: 1,
            'round': 1,
            'rounded': 1,
            'circle': 1,
            2: 2,
            'projecting': 2,
            'project': 2,
            'square': 2,
            'bevel': 2
        };

        /**
         * Sets the line cap styles
         * See {jsPDF.CapJoinStyles} for variants
         *
         * @param {String|Number} style A string or number identifying the type of line cap
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setLineCap
         */
        API.setLineCap = function (style) {
            var id = this.CapJoinStyles[style];
            if (id === undefined) {
                throw new Error("Line cap style of '" + style + "' is not recognized. See or extend .CapJoinStyles property for valid styles");
            }
            lineCapID = id;
            out(id + ' J');

            return this;
        };

        /**
         * Sets the line join styles
         * See {jsPDF.CapJoinStyles} for variants
         *
         * @param {String|Number} style A string or number identifying the type of line join
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setLineJoin
         */
        API.setLineJoin = function (style) {
            var id = this.CapJoinStyles[style];
            if (id === undefined) {
                throw new Error("Line join style of '" + style + "' is not recognized. See or extend .CapJoinStyles property for valid styles");
            }
            lineJoinID = id;
            out(id + ' j');

            return this;
        };

        /**
         * Sets the miter limit.
         * @param {number} miterLimit
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setMiterLimit
         */
        API.setLineMiterLimit = function (miterLimit) {
            out(f2(miterLimit) + " M");

            return this;
        };

        /**
         * Sets the line dash pattern.
         * @param {Array<number>} array An array containing 0-2 numbers. The first number sets the length of the
         * dashes, the second number the length of the gaps. If the second number is missing, the gaps are considered
         * to be as long as the dashes. An empty array means solid, unbroken lines.
         * @param phase The phase lines start with.
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name setLineDashPattern
         */
        API.setLineDashPattern = function (array, phase) {
            out([
                "[" + (array[0] !== undefined ? array[0] : ""),
                (array[1] !== undefined ? array[1] : "") + "]",
                phase,
                "d"
            ].join(" "));

            return this;
        };

        // Output is both an internal (for plugins) and external function
        API.output = output;

        /**
         * Saves as PDF document. An alias of jsPDF.output('save', 'filename.pdf')
         * @param  {String} filename The filename including extension.
         *
         * @function
         * @returns {jsPDF}
         * @methodOf jsPDF#
         * @name save
         */
        API.save = function (filename) {
            API.output('save', filename);
        };

        // applying plugins (more methods) ON TOP of built-in API.
        // this is intentional as we allow plugins to override
        // built-ins
        for (var plugin in jsPDF.API) {
            if (jsPDF.API.hasOwnProperty(plugin)) {
                if (plugin === 'events' && jsPDF.API.events.length) {
                    (function (events, newEvents) {

                        // jsPDF.API.events is a JS Array of Arrays
                        // where each Array is a pair of event name, handler
                        // Events were added by plugins to the jsPDF instantiator.
                        // These are always added to the new instance and some ran
                        // during instantiation.
                        var eventname, handler_and_args, i;

                        for (i = newEvents.length - 1; i !== -1; i--) {
                            // subscribe takes 3 args: 'topic', function, runonce_flag
                            // if undefined, runonce is false.
                            // users can attach callback directly,
                            // or they can attach an array with [callback, runonce_flag]
                            // that's what the "apply" magic is for below.
                            eventname = newEvents[i][0];
                            handler_and_args = newEvents[i][1];
                            events.subscribe.apply(
                                events,
                                [eventname].concat(
                                    typeof handler_and_args === 'function' ?
                                        [handler_and_args] : handler_and_args));
                        }
                    }(events, jsPDF.API.events));
                } else {
                    API[plugin] = jsPDF.API[plugin];
                }
            }
        }

        //////////////////////////////////////////////////////
        // continuing initialization of jsPDF Document object
        //////////////////////////////////////////////////////
        // Add the first page automatically
        addFonts();
        activeFontKey = 'F1';
        _addPage(format, orientation);

        events.publish('initialized');
        return API;
    }

    /**
     * jsPDF.API is a STATIC property of jsPDF class.
     * jsPDF.API is an object you can add methods and properties to.
     * The methods / properties you add will show up in new jsPDF objects.
     *
     * One property is prepopulated. It is the 'events' Object. Plugin authors can add topics,
     * callbacks to this object. These will be reassigned to all new instances of jsPDF.
     * Examples:
     * jsPDF.API.events['initialized'] = function(){ 'this' is API object }
     * jsPDF.API.events['addFont'] = function(added_font_object){ 'this' is API object }
     *
     * @static
     * @public
     * @memberOf jsPDF
     * @name API
     *
     * @example
     * jsPDF.API.mymethod = function(){
     *   // 'this' will be ref to internal API object. see jsPDF source
     *   // , so you can refer to built-in methods like so:
     *   //     this.line(....)
     *   //     this.text(....)
     * }
     * var pdfdoc = new jsPDF()
     * pdfdoc.mymethod() // <- !!!!!!
     */
    jsPDF.API = {events: []};
    jsPDF.version = "1.0.0-trunk";

    if (typeof define === 'function' && define.amd) {
        define('jsPDF', function () {
            return jsPDF;
        });
    } else if (typeof module !== 'undefined' && module.exports) {
        module.exports = jsPDF;
    } else {
        global.jsPDF = jsPDF;
    }
    return jsPDF;
}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || this));
